home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / pygtk / 2.0 / codegen / reversewrapper.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2006-01-20  |  27KB  |  693 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import argtypes
  5.  
  6. def join_ctype_name(ctype, name):
  7.     '''Joins a C type and a variable name into a single string'''
  8.     if ctype[-1] != '*':
  9.         return ' '.join((ctype, name))
  10.     else:
  11.         return ''.join((ctype, name))
  12.  
  13.  
  14. class CodeSink(object):
  15.     
  16.     def __init__(self):
  17.         self.indent_level = 0
  18.         self.indent_stack = []
  19.  
  20.     
  21.     def _format_code(self, code):
  22.         l = []
  23.         for line in code.split('\n'):
  24.             l.append(' ' * self.indent_level + line)
  25.         
  26.         if l[-1]:
  27.             l.append('')
  28.         
  29.         return '\n'.join(l)
  30.  
  31.     
  32.     def writeln(self, line = ''):
  33.         raise NotImplementedError
  34.  
  35.     
  36.     def indent(self, level = 4):
  37.         '''Add a certain ammount of indentation to all lines written
  38.         from now on and until unindent() is called'''
  39.         self.indent_stack.append(self.indent_level)
  40.         self.indent_level += level
  41.  
  42.     
  43.     def unindent(self):
  44.         '''Revert indentation level to the value before last indent() call'''
  45.         self.indent_level = self.indent_stack.pop()
  46.  
  47.  
  48.  
  49. class FileCodeSink(CodeSink):
  50.     
  51.     def __init__(self, fp):
  52.         CodeSink.__init__(self)
  53.         self.fp = fp
  54.  
  55.     
  56.     def writeln(self, line = ''):
  57.         self.fp.write(self._format_code(line))
  58.  
  59.  
  60.  
  61. class MemoryCodeSink(CodeSink):
  62.     
  63.     def __init__(self):
  64.         CodeSink.__init__(self)
  65.         self.lines = []
  66.  
  67.     
  68.     def writeln(self, line = ''):
  69.         self.lines.append(self._format_code(line))
  70.  
  71.     
  72.     def flush_to(self, sink):
  73.         for line in self.lines:
  74.             sink.writeln(line.rstrip())
  75.         
  76.         self.lines = []
  77.  
  78.     
  79.     def flush(self):
  80.         l = []
  81.         for line in self.lines:
  82.             l.append(self._format_code(line))
  83.         
  84.         self.lines = []
  85.         return ''.join(l)
  86.  
  87.  
  88.  
  89. class ReverseWrapper(object):
  90.     '''Object that generates a C->Python wrapper'''
  91.     
  92.     def __init__(self, cname, is_static = True):
  93.         self.cname = cname
  94.         self.called_pyobj = None
  95.         self.method_name = None
  96.         self.is_static = is_static
  97.         self.parameters = []
  98.         self.declarations = MemoryCodeSink()
  99.         self.body = MemoryCodeSink()
  100.         self.cleanup_actions = []
  101.         self.pyargv_items = []
  102.         self.pyargv_optional_items = []
  103.  
  104.     
  105.     def set_call_target(self, called_pyobj, method_name = None):
  106.         self.called_pyobj = called_pyobj
  107.         self.method_name = method_name
  108.  
  109.     
  110.     def set_return_type(self, return_type):
  111.         self.return_type = return_type
  112.  
  113.     
  114.     def add_parameter(self, param):
  115.         self.parameters.append(param)
  116.  
  117.     
  118.     def add_declaration(self, decl_code):
  119.         self.declarations.writeln(decl_code)
  120.  
  121.     
  122.     def add_pyargv_item(self, variable, optional = False):
  123.         if optional:
  124.             self.pyargv_optional_items.append(variable)
  125.         else:
  126.             self.pyargv_items.append(variable)
  127.  
  128.     
  129.     def write_code(self, code, cleanup = None, failure_expression = None, failure_cleanup = None):
  130.         '''Add a chunk of code with cleanup and error handling
  131.  
  132.         This method is to be used by TypeHandlers when generating code
  133.  
  134.         Keywork arguments:
  135.         code -- code to add
  136.         cleanup -- code to cleanup any dynamic resources created by @code
  137.                    (except in case of failure) (default None)
  138.         failure_expression -- C boolean expression to indicate
  139.                               if anything failed (default None)
  140.         failure_cleanup -- code to cleanup any dynamic resources
  141.                            created by @code in case of failure (default None)
  142.         '''
  143.         if code is not None:
  144.             self.body.writeln(code)
  145.         
  146.         if failure_expression is not None:
  147.             self.body.writeln('if (%s) {' % failure_expression)
  148.             self.body.indent()
  149.             self.body.writeln('if (PyErr_Occurred())')
  150.             self.body.indent()
  151.             self.body.writeln('PyErr_Print();')
  152.             self.body.unindent()
  153.             if failure_cleanup is not None:
  154.                 self.body.writeln(failure_cleanup)
  155.             
  156.             for cleanup_action in self.cleanup_actions:
  157.                 self.body.writeln(cleanup_action)
  158.             
  159.             self.return_type.write_error_return()
  160.             self.body.unindent()
  161.             self.body.writeln('}')
  162.         
  163.         if cleanup is not None:
  164.             self.cleanup_actions.insert(0, cleanup)
  165.         
  166.  
  167.     
  168.     def generate(self, sink):
  169.         '''Generate the code into a CodeSink object'''
  170.         self.add_declaration('PyGILState_STATE __py_state;')
  171.         self.write_code(code = '__py_state = pyg_gil_state_ensure();', cleanup = 'pyg_gil_state_release(__py_state);')
  172.         for param in self.parameters:
  173.             param.convert_c2py()
  174.         
  175.         if self.is_static:
  176.             sink.writeln('static %s' % self.return_type.get_c_type())
  177.         else:
  178.             sink.writeln(self.return_type.get_c_type())
  179.         c_proto_params = map(Parameter.format_for_c_proto, self.parameters)
  180.         sink.writeln('%s(%s)\n{' % (self.cname, ', '.join(c_proto_params)))
  181.         self.return_type.write_decl()
  182.         self.add_declaration('PyObject *py_retval;')
  183.         if self.pyargv_items:
  184.             self.add_declaration('PyObject *py_args;')
  185.             py_args = 'py_args'
  186.             if self.pyargv_optional_items:
  187.                 self.add_declaration('int argc = %i;' % len(self.pyargv_items))
  188.                 argc = 'argc'
  189.                 for arg in self.pyargv_optional_items:
  190.                     self.body.writeln('if (%s)' % arg)
  191.                     self.body.indent()
  192.                     self.body.writeln('++argc;')
  193.                     self.body.unindent()
  194.                 
  195.             else:
  196.                 argc = str(len(self.pyargv_items))
  197.         elif self.pyargv_optional_items:
  198.             self.add_declaration('PyObject *py_args;')
  199.             py_args = 'py_args'
  200.             self.add_declaration('int argc = 0;')
  201.             argc = 'argc'
  202.             for arg in self.pyargv_optional_items:
  203.                 self.body.writeln('if (%s)' % arg)
  204.                 self.body.indent()
  205.                 self.body.writeln('++argc;')
  206.                 self.body.unindent()
  207.             
  208.         else:
  209.             py_args = 'NULL'
  210.             argc = None
  211.         self.body.writeln()
  212.         if py_args != 'NULL':
  213.             self.write_code('py_args = PyTuple_New(%s);' % argc, cleanup = 'Py_DECREF(py_args);')
  214.             pos = 0
  215.             for arg in self.pyargv_items:
  216.                 
  217.                 try:
  218.                     self.cleanup_actions.remove('Py_DECREF(%s);' % arg)
  219.                 except ValueError:
  220.                     self.body.writeln('Py_INCREF(%s);' % arg)
  221.  
  222.                 self.body.writeln('PyTuple_SET_ITEM(%s, %i, %s);' % (py_args, pos, arg))
  223.                 pos += 1
  224.             
  225.             for arg in self.pyargv_optional_items:
  226.                 self.body.writeln('if (%s) {' % arg)
  227.                 self.body.indent()
  228.                 
  229.                 try:
  230.                     self.cleanup_actions.remove('Py_XDECREF(%s);' % arg)
  231.                 except ValueError:
  232.                     self.body.writeln('Py_INCREF(%s);' % arg)
  233.  
  234.                 self.body.writeln('PyTuple_SET_ITEM(%s, %i, %s);' % (py_args, pos, arg))
  235.                 self.body.unindent()
  236.                 self.body.writeln('}')
  237.                 pos += 1
  238.             
  239.         
  240.         self.body.writeln()
  241.         if self.method_name is None:
  242.             self.write_code('py_retval = PyObject_Call(%s, %s);' % (self.called_pyobj, py_args), cleanup = 'Py_DECREF(py_retval);', failure_expression = '!py_retval')
  243.         else:
  244.             self.add_declaration('PyObject *py_method;')
  245.             self.write_code('py_method = PyObject_GetAttrString(%s, "%s");' % (self.called_pyobj, self.method_name), cleanup = 'Py_DECREF(py_method);', failure_expression = '!py_method')
  246.             self.write_code('py_retval = PyObject_CallObject(py_method, %s);' % (py_args,), cleanup = 'Py_DECREF(py_retval);', failure_expression = '!py_retval')
  247.         self.return_type.write_conversion()
  248.         sink.indent()
  249.         self.declarations.flush_to(sink)
  250.         sink.writeln()
  251.         self.body.flush_to(sink)
  252.         sink.writeln()
  253.         for cleanup_action in self.cleanup_actions:
  254.             sink.writeln(cleanup_action)
  255.         
  256.         if self.return_type.get_c_type() != 'void':
  257.             sink.writeln()
  258.             sink.writeln('return retval;')
  259.         
  260.         sink.unindent()
  261.         sink.writeln('}')
  262.  
  263.  
  264.  
  265. class TypeHandler(object):
  266.     
  267.     def __init__(self, wrapper, **props):
  268.         self.wrapper = wrapper
  269.         self.props = props
  270.  
  271.  
  272.  
  273. class ReturnType(TypeHandler):
  274.     
  275.     def get_c_type(self):
  276.         raise NotImplementedError
  277.  
  278.     
  279.     def write_decl(self):
  280.         raise NotImplementedError
  281.  
  282.     
  283.     def write_error_return(self):
  284.         '''Write "return <value>" code in case of error'''
  285.         raise NotImplementedError
  286.  
  287.     
  288.     def write_conversion(self):
  289.         """Writes code to convert Python return value in 'py_retval'
  290.         into C 'retval'.  Returns a string with C boolean expression
  291.         that determines if anything went wrong. """
  292.         raise NotImplementedError
  293.  
  294.  
  295.  
  296. class Parameter(TypeHandler):
  297.     
  298.     def __init__(self, wrapper, name, **props):
  299.         TypeHandler.__init__(self, wrapper, **props)
  300.         self.name = name
  301.  
  302.     
  303.     def get_c_type(self):
  304.         raise NotImplementedError
  305.  
  306.     
  307.     def convert_c2py(self):
  308.         '''Write some code before calling the Python method.'''
  309.         pass
  310.  
  311.     
  312.     def format_for_c_proto(self):
  313.         return join_ctype_name(self.get_c_type(), self.name)
  314.  
  315.  
  316.  
  317. class StringParam(Parameter):
  318.     
  319.     def get_c_type(self):
  320.         return self.props.get('c_type', 'char *').replace('const-', 'const ')
  321.  
  322.     
  323.     def convert_c2py(self):
  324.         if self.props.get('optional', False):
  325.             self.wrapper.add_declaration('PyObject *py_%s = NULL;' % self.name)
  326.             self.wrapper.write_code(code = 'if (%s)\n    py_%s = PyString_FromString(%s);\n' % (self.name, self.name, self.name), cleanup = 'Py_XDECREF(py_%s);' % self.name)
  327.             self.wrapper.add_pyargv_item('py_%s' % self.name, optional = True)
  328.         else:
  329.             self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  330.             self.wrapper.write_code(code = 'py_%s = PyString_FromString(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  331.             self.wrapper.add_pyargv_item('py_%s' % self.name)
  332.  
  333.  
  334. for ctype in ('char*', 'gchar*', 'const-char*', 'char-const*', 'const-gchar*', 'gchar-const*', 'string', 'static_string'):
  335.     argtypes.matcher.register_reverse(ctype, StringParam)
  336.  
  337.  
  338. class StringReturn(ReturnType):
  339.     
  340.     def get_c_type(self):
  341.         return 'char *'
  342.  
  343.     
  344.     def write_decl(self):
  345.         self.wrapper.add_declaration('char *retval;')
  346.  
  347.     
  348.     def write_error_return(self):
  349.         self.wrapper.write_code('return NULL;')
  350.  
  351.     
  352.     def write_conversion(self):
  353.         self.wrapper.write_code(code = None, failure_expression = '!PyString_Check(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a string");')
  354.         self.wrapper.write_code('retval = g_strdup(PyString_AsString(py_retval));')
  355.  
  356.  
  357. for ctype in ('char*', 'gchar*'):
  358.     argtypes.matcher.register_reverse(ctype, StringReturn)
  359.  
  360.  
  361. class VoidReturn(ReturnType):
  362.     
  363.     def get_c_type(self):
  364.         return 'void'
  365.  
  366.     
  367.     def write_decl(self):
  368.         pass
  369.  
  370.     
  371.     def write_error_return(self):
  372.         self.wrapper.write_code('return;')
  373.  
  374.     
  375.     def write_conversion(self):
  376.         self.wrapper.write_code(code = None, failure_expression = 'py_retval != Py_None', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be None");')
  377.  
  378.  
  379. argtypes.matcher.register_reverse_ret('void', VoidReturn)
  380. argtypes.matcher.register_reverse_ret('none', VoidReturn)
  381.  
  382. class GObjectParam(Parameter):
  383.     
  384.     def get_c_type(self):
  385.         return self.props.get('c_type', 'GObject *')
  386.  
  387.     
  388.     def convert_c2py(self):
  389.         self.wrapper.add_declaration('PyObject *py_%s = NULL;' % self.name)
  390.         self.wrapper.write_code(code = 'if (%s)\n    py_%s = pygobject_new((GObject *) %s);\nelse {\n    Py_INCREF(Py_None);\n    py_%s = Py_None;\n}' % (self.name, self.name, self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  391.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  392.  
  393.  
  394. argtypes.matcher.register_reverse('GObject*', GObjectParam)
  395.  
  396. class GObjectReturn(ReturnType):
  397.     
  398.     def get_c_type(self):
  399.         return self.props.get('c_type', 'GObject *')
  400.  
  401.     
  402.     def write_decl(self):
  403.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  404.  
  405.     
  406.     def write_error_return(self):
  407.         self.wrapper.write_code('return NULL;')
  408.  
  409.     
  410.     def write_conversion(self):
  411.         self.wrapper.write_code('retval = (%s) pygobject_get(py_retval);' % self.get_c_type())
  412.         self.wrapper.write_code('g_object_ref((GObject *) retval);')
  413.  
  414.  
  415. argtypes.matcher.register_reverse_ret('GObject*', GObjectReturn)
  416.  
  417. class IntParam(Parameter):
  418.     
  419.     def get_c_type(self):
  420.         return self.props.get('c_type', 'int')
  421.  
  422.     
  423.     def convert_c2py(self):
  424.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  425.         self.wrapper.write_code(code = 'py_%s = PyInt_FromLong(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  426.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  427.  
  428.  
  429.  
  430. class IntReturn(ReturnType):
  431.     
  432.     def get_c_type(self):
  433.         return self.props.get('c_type', 'int')
  434.  
  435.     
  436.     def write_decl(self):
  437.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  438.  
  439.     
  440.     def write_error_return(self):
  441.         self.wrapper.write_code('return -G_MAXINT;')
  442.  
  443.     
  444.     def write_conversion(self):
  445.         self.wrapper.write_code(code = None, failure_expression = '!PyInt_Check(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be an int");')
  446.         self.wrapper.write_code('retval = PyInt_AsLong(py_retval);')
  447.  
  448.  
  449. for argtype in ('int', 'gint', 'guint', 'short', 'gshort', 'gushort', 'long', 'glong', 'gsize', 'gssize', 'guint8', 'gint8', 'guint16', 'gint16', 'gint32', 'GTime'):
  450.     argtypes.matcher.register_reverse(argtype, IntParam)
  451.     argtypes.matcher.register_reverse_ret(argtype, IntReturn)
  452.  
  453.  
  454. class GEnumReturn(IntReturn):
  455.     
  456.     def write_conversion(self):
  457.         self.wrapper.write_code(code = None, failure_expression = 'pyg_enum_get_value(%s, py_retval, (gint *)&retval)' % self.props['typecode'])
  458.  
  459.  
  460. argtypes.matcher.register_reverse_ret('GEnum', GEnumReturn)
  461.  
  462. class GEnumParam(IntParam):
  463.     
  464.     def convert_c2py(self):
  465.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  466.         self.wrapper.write_code(code = 'py_%s = pyg_enum_from_gtype(%s, %s);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  467.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  468.  
  469.  
  470. argtypes.matcher.register_reverse('GEnum', GEnumParam)
  471.  
  472. class GFlagsReturn(IntReturn):
  473.     
  474.     def write_conversion(self):
  475.         self.wrapper.write_code(code = None, failure_expression = 'pyg_flags_get_value(%s, py_retval, (gint *)&retval)' % self.props['typecode'])
  476.  
  477.  
  478. argtypes.matcher.register_reverse_ret('GFlags', GFlagsReturn)
  479.  
  480. class GFlagsParam(IntParam):
  481.     
  482.     def convert_c2py(self):
  483.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  484.         self.wrapper.write_code(code = 'py_%s = pyg_flags_from_gtype(%s, %s);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  485.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  486.  
  487.  
  488. argtypes.matcher.register_reverse('GFlags', GFlagsParam)
  489.  
  490. class GtkTreePathParam(IntParam):
  491.     
  492.     def convert_c2py(self):
  493.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  494.         self.wrapper.write_code(code = 'py_%s = pygtk_tree_path_to_pyobject(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  495.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  496.  
  497.  
  498. argtypes.matcher.register_reverse('GtkTreePath*', GtkTreePathParam)
  499.  
  500. class BooleanReturn(ReturnType):
  501.     
  502.     def get_c_type(self):
  503.         return 'gboolean'
  504.  
  505.     
  506.     def write_decl(self):
  507.         self.wrapper.add_declaration('gboolean retval;')
  508.  
  509.     
  510.     def write_error_return(self):
  511.         self.wrapper.write_code('return FALSE;')
  512.  
  513.     
  514.     def write_conversion(self):
  515.         self.wrapper.write_code('retval = PyObject_IsTrue(py_retval)? TRUE : FALSE;')
  516.  
  517.  
  518. argtypes.matcher.register_reverse_ret('gboolean', BooleanReturn)
  519.  
  520. class BooleanParam(Parameter):
  521.     
  522.     def get_c_type(self):
  523.         return 'gboolean'
  524.  
  525.     
  526.     def convert_c2py(self):
  527.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  528.         self.wrapper.write_code('py_%s = %s? Py_True : Py_False;' % (self.name, self.name))
  529.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  530.  
  531.  
  532. argtypes.matcher.register_reverse('gboolean', BooleanParam)
  533.  
  534. class DoubleParam(Parameter):
  535.     
  536.     def get_c_type(self):
  537.         return self.props.get('c_type', 'gdouble')
  538.  
  539.     
  540.     def convert_c2py(self):
  541.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  542.         self.wrapper.write_code(code = 'py_%s = PyFloat_FromDouble(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  543.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  544.  
  545.  
  546.  
  547. class DoubleReturn(ReturnType):
  548.     
  549.     def get_c_type(self):
  550.         return self.props.get('c_type', 'gdouble')
  551.  
  552.     
  553.     def write_decl(self):
  554.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  555.  
  556.     
  557.     def write_error_return(self):
  558.         self.wrapper.write_code('return -G_MAXFLOAT;')
  559.  
  560.     
  561.     def write_conversion(self):
  562.         self.wrapper.write_code(code = None, failure_expression = '!PyFloat_AsDouble(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a float");')
  563.         self.wrapper.write_code('retval = PyFloat_AsDouble(py_retval);')
  564.  
  565.  
  566. for argtype in ('float', 'double', 'gfloat', 'gdouble'):
  567.     argtypes.matcher.register_reverse(argtype, DoubleParam)
  568.     argtypes.matcher.register_reverse_ret(argtype, DoubleReturn)
  569.  
  570.  
  571. class GBoxedParam(Parameter):
  572.     
  573.     def get_c_type(self):
  574.         return self.props.get('c_type').replace('const-', 'const ')
  575.  
  576.     
  577.     def convert_c2py(self):
  578.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  579.         ctype = self.get_c_type()
  580.         if ctype.startswith('const '):
  581.             ctype_no_const = ctype[len('const '):]
  582.             self.wrapper.write_code(code = 'py_%s = pyg_boxed_new(%s, (%s) %s, TRUE, TRUE);' % (self.name, self.props['typecode'], ctype_no_const, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  583.         else:
  584.             self.wrapper.write_code(code = 'py_%s = pyg_boxed_new(%s, %s, FALSE, FALSE);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  585.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  586.  
  587.  
  588. argtypes.matcher.register_reverse('GBoxed', GBoxedParam)
  589.  
  590. class GBoxedReturn(ReturnType):
  591.     
  592.     def get_c_type(self):
  593.         return self.props.get('c_type')
  594.  
  595.     
  596.     def write_decl(self):
  597.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  598.  
  599.     
  600.     def write_error_return(self):
  601.         self.wrapper.write_code('return retval;')
  602.  
  603.     
  604.     def write_conversion(self):
  605.         self.wrapper.write_code(failure_expression = '!pyg_boxed_check(py_retval, %s)' % (self.props['typecode'],), failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a %s");' % (self.props['typename'],))
  606.         self.wrapper.write_code('retval = pyg_boxed_get(py_retval, %s);' % self.props['typename'])
  607.  
  608.  
  609. argtypes.matcher.register_reverse_ret('GBoxed', GBoxedReturn)
  610.  
  611. class GdkRectanglePtrParam(Parameter):
  612.     
  613.     def get_c_type(self):
  614.         return self.props.get('c_type').replace('const-', 'const ')
  615.  
  616.     
  617.     def convert_c2py(self):
  618.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  619.         self.wrapper.write_code(code = 'py_%(name)s = Py_BuildValue("(ffff)", %(name)s->x, %(name)s->y,\n                            %(name)s->width, %(name)s->height);' % dict(name = self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  620.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  621.  
  622.  
  623. argtypes.matcher.register_reverse('GdkRectangle*', GdkRectanglePtrParam)
  624.  
  625. class PyGObjectMethodParam(Parameter):
  626.     
  627.     def __init__(self, wrapper, name, method_name, **props):
  628.         Parameter.__init__(self, wrapper, name, **props)
  629.         self.method_name = method_name
  630.  
  631.     
  632.     def get_c_type(self):
  633.         return self.props.get('c_type', 'GObject *')
  634.  
  635.     
  636.     def convert_c2py(self):
  637.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  638.         self.wrapper.write_code(code = 'py_%s = pygobject_new((GObject *) %s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  639.         self.wrapper.set_call_target('py_%s' % self.name, self.method_name)
  640.  
  641.  
  642.  
  643. class CallbackInUserDataParam(Parameter):
  644.     
  645.     def __init__(self, wrapper, name, free_it, **props):
  646.         Parameter.__init__(self, wrapper, name, **props)
  647.         self.free_it = free_it
  648.  
  649.     
  650.     def get_c_type(self):
  651.         return 'gpointer'
  652.  
  653.     
  654.     def convert_c2py(self):
  655.         self.wrapper.add_declaration('PyObject **_user_data;')
  656.         if not self.free_it or 'g_free(%s);' % self.name:
  657.             pass
  658.         cleanup = None
  659.         self.wrapper.write_code(code = '_real_user_data = (PyObject **) %s;' % self.name, cleanup = cleanup)
  660.         self.wrapper.add_declaration('PyObject *py_func;')
  661.         if not self.free_it or 'Py_DECREF(py_func);':
  662.             pass
  663.         cleanup = None
  664.         self.wrapper.write_code(code = 'py_func = _user_data[0];', cleanup = cleanup)
  665.         self.wrapper.set_call_target('py_func')
  666.         self.wrapper.add_declaration('PyObject *py_user_data;')
  667.         if not self.free_it or 'Py_XDECREF(py_user_data);':
  668.             pass
  669.         cleanup = None
  670.         self.wrapper.write_code(code = 'py_user_data = _user_data[1];', cleanup = cleanup)
  671.         self.wrapper.add_pyargv_item('py_user_data', optional = True)
  672.  
  673.  
  674.  
  675. def _test():
  676.     import sys as sys
  677.     wrapper = ReverseWrapper('this_is_the_c_function_name', is_static = True)
  678.     wrapper.set_return_type(StringReturn(wrapper))
  679.     wrapper.add_parameter(PyGObjectMethodParam(wrapper, 'self', method_name = 'do_xxx'))
  680.     wrapper.add_parameter(StringParam(wrapper, 'param2', optional = True))
  681.     wrapper.add_parameter(GObjectParam(wrapper, 'param3'))
  682.     wrapper.generate(FileCodeSink(sys.stderr))
  683.     wrapper = ReverseWrapper('this_a_callback_wrapper')
  684.     wrapper.set_return_type(VoidReturn(wrapper))
  685.     wrapper.add_parameter(StringParam(wrapper, 'param1', optional = False))
  686.     wrapper.add_parameter(GObjectParam(wrapper, 'param2'))
  687.     wrapper.add_parameter(CallbackInUserDataParam(wrapper, 'data', free_it = True))
  688.     wrapper.generate(FileCodeSink(sys.stderr))
  689.  
  690. if __name__ == '__main__':
  691.     _test()
  692.  
  693.